/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_conv2d_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/nested_pairs_to_triple.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/conv2d/selector_list.h"
#include "test/conv2d/window_stride_fixture.h"

#include <array>
#include <vector>

using DataTypeList = sycldnn::types::KernelDataTypes;
using Selectors = sycldnn::types::SelectorList;
using Backends = sycldnn::types::AllBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<Selectors, DataTypeList>::type;
using BackendTypePairs =
    sycldnn::types::CartesianProduct<SNNTypePairs, Backends>::type;
using TestTriples = sycldnn::types::NestedPairsToTriple<BackendTypePairs>::type;

using GTestTypeTriples = sycldnn::types::ToGTestTypes<TestTriples>::type;

template <typename Pair>
using FilterBackpropWindow1Stride2 = WindowStrideTest<Pair, 1, 2>;
TYPED_TEST_SUITE(FilterBackpropWindow1Stride2, GTestTypeTriples);
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x3x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {64.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x3x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {64.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x3x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {108., 128.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x3x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {108., 128.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x3x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {196., 216., 236., 256.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x3x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {196., 216., 236., 256.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x3x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {118., 128.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x3x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {118., 128.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x3x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {200., 236., 216., 256.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x3x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {200., 236., 216., 256.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x3x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {364., 400., 436., 472.,
                                         392., 432., 472., 512.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x3x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {364., 400., 436., 472.,
                                         392., 432., 472., 512.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x3x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {226., 236., 246., 256.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x3x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {226., 236., 246., 256.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x3x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {384., 452., 400., 472.,
                                         416., 492., 432., 512.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x3x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {384., 452., 400., 472.,
                                         416., 492., 432., 512.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x3x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {700., 768., 836., 904., 728., 800.,
                                         872., 944., 756., 832., 908., 984.,
                                         784., 864., 944., 1024.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x3x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {700., 768., 836., 904., 728., 800.,
                                         872., 944., 756., 832., 908., 984.,
                                         784., 864., 944., 1024.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x3x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {78.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x3x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {78.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x3x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {132., 156.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x3x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {132., 156.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x3x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {240., 264., 288., 312.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x3x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {240., 264., 288., 312.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x3x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {146., 156.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x3x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {146., 156.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x3x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {248., 292., 264., 312.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x3x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {248., 292., 264., 312.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x3x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {452., 496., 540., 584.,
                                         480., 528., 576., 624.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x3x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {452., 496., 540., 584.,
                                         480., 528., 576., 624.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x3x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {282., 292., 302., 312.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x3x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {282., 292., 302., 312.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x3x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {480., 564., 496., 584.,
                                         512., 604., 528., 624.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x3x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {480., 564., 496., 584.,
                                         512., 604., 528., 624.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x3x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      876., 960.,  1044., 1128., 904., 992.,  1080., 1168.,
      932., 1024., 1116., 1208., 960., 1056., 1152., 1248.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x3x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      876., 960.,  1044., 1128., 904., 992.,  1080., 1168.,
      932., 1024., 1116., 1208., 960., 1056., 1152., 1248.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x3x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {251.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x3x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {251.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x3x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {448., 502.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x3x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {448., 502.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x3x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {842., 896., 950., 1004.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x3x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {842., 896., 950., 1004.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x3x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {481., 502.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x3x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {481., 502.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x3x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {860., 962., 896., 1004.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x3x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {860., 962., 896., 1004.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x3x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1618., 1720., 1822., 1924.,
                                         1684., 1792., 1900., 2008.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x3x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1618., 1720., 1822., 1924.,
                                         1684., 1792., 1900., 2008.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x3x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {941., 962., 983., 1004.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x3x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {941., 962., 983., 1004.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x3x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1684., 1882., 1720., 1924.,
                                         1756., 1966., 1792., 2008.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x3x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1684., 1882., 1720., 1924.,
                                         1756., 1966., 1792., 2008.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x3x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3170., 3368., 3566., 3764., 3236., 3440., 3644., 3848.,
      3302., 3512., 3722., 3932., 3368., 3584., 3800., 4016.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x3x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3170., 3368., 3566., 3764., 3236., 3440., 3644., 3848.,
      3302., 3512., 3722., 3932., 3368., 3584., 3800., 4016.};
  const std::array<int, 4> in_shape = {{1, 3, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x4x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {64.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x4x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {64.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x4x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {108., 128.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x4x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {108., 128.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x4x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {196., 216., 236., 256.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x4x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {196., 216., 236., 256.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x4x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {118., 128.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x4x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {118., 128.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x4x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {200., 236., 216., 256.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x4x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {200., 236., 216., 256.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x4x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {364., 400., 436., 472.,
                                         392., 432., 472., 512.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x4x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {364., 400., 436., 472.,
                                         392., 432., 472., 512.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x4x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {226., 236., 246., 256.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x4x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {226., 236., 246., 256.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x4x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {384., 452., 400., 472.,
                                         416., 492., 432., 512.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x4x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {384., 452., 400., 472.,
                                         416., 492., 432., 512.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x4x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {700., 768., 836., 904., 728., 800.,
                                         872., 944., 756., 832., 908., 984.,
                                         784., 864., 944., 1024.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x4x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {700., 768., 836., 904., 728., 800.,
                                         872., 944., 756., 832., 908., 984.,
                                         784., 864., 944., 1024.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {78.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {78.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {132., 156.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {132., 156.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {240., 264., 288., 312.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {240., 264., 288., 312.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {146., 156.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {146., 156.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {248., 292., 264., 312.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {248., 292., 264., 312.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {452., 496., 540., 584.,
                                         480., 528., 576., 624.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {452., 496., 540., 584.,
                                         480., 528., 576., 624.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {282., 292., 302., 312.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {282., 292., 302., 312.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {480., 564., 496., 584.,
                                         512., 604., 528., 624.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {480., 564., 496., 584.,
                                         512., 604., 528., 624.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      876., 960.,  1044., 1128., 904., 992.,  1080., 1168.,
      932., 1024., 1116., 1208., 960., 1056., 1152., 1248.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      876., 960.,  1044., 1128., 904., 992.,  1080., 1168.,
      932., 1024., 1116., 1208., 960., 1056., 1152., 1248.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x4x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {251.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x4x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {251.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x4x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {448., 502.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x4x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {448., 502.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x4x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {842., 896., 950., 1004.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x4x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {842., 896., 950., 1004.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x4x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {481., 502.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x4x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {481., 502.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x4x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {860., 962., 896., 1004.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x4x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {860., 962., 896., 1004.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x4x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1618., 1720., 1822., 1924.,
                                         1684., 1792., 1900., 2008.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x4x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1618., 1720., 1822., 1924.,
                                         1684., 1792., 1900., 2008.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x4x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {941., 962., 983., 1004.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x4x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {941., 962., 983., 1004.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x4x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1684., 1882., 1720., 1924.,
                                         1756., 1966., 1792., 2008.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x4x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1684., 1882., 1720., 1924.,
                                         1756., 1966., 1792., 2008.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x4x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3170., 3368., 3566., 3764., 3236., 3440., 3644., 3848.,
      3302., 3512., 3722., 3932., 3368., 3584., 3800., 4016.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x4x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3170., 3368., 3566., 3764., 3236., 3440., 3644., 3848.,
      3302., 3512., 3722., 3932., 3368., 3584., 3800., 4016.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x6x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {219.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x6x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {219.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x6x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {390., 438.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x6x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {390., 438.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x6x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {732., 780., 828., 876.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x6x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {732., 780., 828., 876.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x6x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {417., 438.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x6x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {417., 438.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x6x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {744., 834., 780., 876.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x6x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {744., 834., 780., 876.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x6x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1398., 1488., 1578., 1668.,
                                         1464., 1560., 1656., 1752.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x6x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1398., 1488., 1578., 1668.,
                                         1464., 1560., 1656., 1752.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x6x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {813., 834., 855., 876.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x6x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {813., 834., 855., 876.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x6x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1452., 1626., 1488., 1668.,
                                         1524., 1710., 1560., 1752.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x6x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1452., 1626., 1488., 1668.,
                                         1524., 1710., 1560., 1752.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x6x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2730., 2904., 3078., 3252., 2796., 2976., 3156., 3336.,
      2862., 3048., 3234., 3420., 2928., 3120., 3312., 3504.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x6x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2730., 2904., 3078., 3252., 2796., 2976., 3156., 3336.,
      2862., 3048., 3234., 3420., 2928., 3120., 3312., 3504.};
  const std::array<int, 4> in_shape = {{1, 6, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x6x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {277.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x6x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {277.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x6x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {494., 554.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x6x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {494., 554.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x6x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {928., 988., 1048., 1108.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x6x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {928., 988., 1048., 1108.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x6x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {533., 554.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x6x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {533., 554.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x6x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {952., 1066., 988., 1108.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x6x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {952., 1066., 988., 1108.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x6x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1790., 1904., 2018., 2132.,
                                         1856., 1976., 2096., 2216.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x6x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1790., 1904., 2018., 2132.,
                                         1856., 1976., 2096., 2216.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x6x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1045., 1066., 1087., 1108.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x6x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1045., 1066., 1087., 1108.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x6x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1868., 2090., 1904., 2132.,
                                         1940., 2174., 1976., 2216.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x6x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1868., 2090., 1904., 2132.,
                                         1940., 2174., 1976., 2216.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x6x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3514., 3736., 3958., 4180., 3580., 3808., 4036., 4264.,
      3646., 3880., 4114., 4348., 3712., 3952., 4192., 4432.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x6x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3514., 3736., 3958., 4180., 3580., 3808., 4036., 4264.,
      3646., 3880., 4114., 4348., 3712., 3952., 4192., 4432.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {903.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {903.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1671., 1806.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1671., 1806.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3207., 3342., 3477., 3612.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3207., 3342., 3477., 3612.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1761., 1806.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1761., 1806.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3261., 3522., 3342., 3612.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3261., 3522., 3342., 3612.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6261., 6522., 6783., 7044.,
                                         6414., 6684., 6954., 7224.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6261., 6522., 6783., 7044.,
                                         6414., 6684., 6954., 7224.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3477., 3522., 3567., 3612.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3477., 3522., 3567., 3612.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6441., 6954., 6522., 7044.,
                                         6603., 7134., 6684., 7224.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6441., 6954., 6522., 7044.,
                                         6603., 7134., 6684., 7224.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME1x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12369., 12882., 13395., 13908., 12522., 13044., 13566., 14088.,
      12675., 13206., 13737., 14268., 12828., 13368., 13908., 14448.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID1x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12369., 12882., 13395., 13908., 12522., 13044., 13566., 14088.,
      12675., 13206., 13737., 14268., 12828., 13368., 13908., 14448.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x3x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1422.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x3x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1422.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x3x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2676., 2844.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x3x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2676., 2844.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x3x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5184., 5352., 5520., 5688.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x3x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5184., 5352., 5520., 5688.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x3x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2766., 2844.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x3x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2766., 2844.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x3x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5208., 5532., 5352., 5688.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x3x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5208., 5532., 5352., 5688.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x3x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {10092., 10416., 10740., 11064.,
                                         10368., 10704., 11040., 11376.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x3x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {10092., 10416., 10740., 11064.,
                                         10368., 10704., 11040., 11376.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x3x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5454., 5532., 5610., 5688.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x3x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5454., 5532., 5610., 5688.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x3x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {10272., 10908., 10416., 11064.,
                                         10560., 11220., 10704., 11376.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x3x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {10272., 10908., 10416., 11064.,
                                         10560., 11220., 10704., 11376.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x3x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19908., 20544., 21180., 21816., 20184., 20832., 21480., 22128.,
      20460., 21120., 21780., 22440., 20736., 21408., 22080., 22752.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x3x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19908., 20544., 21180., 21816., 20184., 20832., 21480., 22128.,
      20460., 21120., 21780., 22440., 20736., 21408., 22080., 22752.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x3x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1842.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x3x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1842.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x3x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3468., 3684.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x3x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3468., 3684.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x3x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6720., 6936., 7152., 7368.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x3x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6720., 6936., 7152., 7368.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x3x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3606., 3684.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x3x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3606., 3684.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x3x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6792., 7212., 6936., 7368.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x3x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6792., 7212., 6936., 7368.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x3x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {13164., 13584., 14004., 14424.,
                                         13440., 13872., 14304., 14736.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x3x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {13164., 13584., 14004., 14424.,
                                         13440., 13872., 14304., 14736.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x3x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7134., 7212., 7290., 7368.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x3x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7134., 7212., 7290., 7368.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x3x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {13440., 14268., 13584., 14424.,
                                         13728., 14580., 13872., 14736.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x3x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {13440., 14268., 13584., 14424.,
                                         13728., 14580., 13872., 14736.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x3x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      26052., 26880., 27708., 28536., 26328., 27168., 28008., 28848.,
      26604., 27456., 28308., 29160., 26880., 27744., 28608., 29472.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x3x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      26052., 26880., 27708., 28536., 26328., 27168., 28008., 28848.,
      26604., 27456., 28308., 29160., 26880., 27744., 28608., 29472.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x3x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6099.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x3x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6099.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x3x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {11712., 12198.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x3x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {11712., 12198.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x3x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {22938., 23424., 23910., 24396.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x3x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {22938., 23424., 23910., 24396.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x3x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {12027., 12198.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x3x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {12027., 12198.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x3x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {23100., 24054., 23424., 24396.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x3x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {23100., 24054., 23424., 24396.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x3x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {45246., 46200., 47154., 48108.,
                                         45876., 46848., 47820., 48792.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x3x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {45246., 46200., 47154., 48108.,
                                         45876., 46848., 47820., 48792.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x3x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {23883., 24054., 24225., 24396.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x3x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {23883., 24054., 24225., 24396.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x3x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {45876., 47766., 46200., 48108.,
                                         46524., 48450., 46848., 48792.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x3x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {45876., 47766., 46200., 48108.,
                                         46524., 48450., 46848., 48792.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x3x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      89862., 91752., 93642., 95532., 90492., 92400., 94308., 96216.,
      91122., 93048., 94974., 96900., 91752., 93696., 95640., 97584.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x3x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      89862., 91752., 93642., 95532., 90492., 92400., 94308., 96216.,
      91122., 93048., 94974., 96900., 91752., 93696., 95640., 97584.};
  const std::array<int, 4> in_shape = {{3, 3, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x4x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1752.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x4x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1752.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x4x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3300., 3504.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x4x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3300., 3504.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x4x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6396., 6600., 6804., 7008.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x4x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6396., 6600., 6804., 7008.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x4x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3426., 3504.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x4x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3426., 3504.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x4x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6456., 6852., 6600., 7008.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x4x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6456., 6852., 6600., 7008.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x4x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {12516., 12912., 13308., 13704.,
                                         12792., 13200., 13608., 14016.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x4x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {12516., 12912., 13308., 13704.,
                                         12792., 13200., 13608., 14016.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x4x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6774., 6852., 6930., 7008.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x4x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6774., 6852., 6930., 7008.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x4x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {12768., 13548., 12912., 13704.,
                                         13056., 13860., 13200., 14016.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x4x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {12768., 13548., 12912., 13704.,
                                         13056., 13860., 13200., 14016.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x4x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24756., 25536., 26316., 27096., 25032., 25824., 26616., 27408.,
      25308., 26112., 26916., 27720., 25584., 26400., 27216., 28032.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x4x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24756., 25536., 26316., 27096., 25032., 25824., 26616., 27408.,
      25308., 26112., 26916., 27720., 25584., 26400., 27216., 28032.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2282.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2282.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4300., 4564.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4300., 4564.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {8336., 8600., 8864., 9128.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {8336., 8600., 8864., 9128.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4486., 4564.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4486., 4564.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {8456., 8972., 8600., 9128.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {8456., 8972., 8600., 9128.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {16396., 16912., 17428., 17944.,
                                         16672., 17200., 17728., 18256.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {16396., 16912., 17428., 17944.,
                                         16672., 17200., 17728., 18256.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {8894., 8972., 9050., 9128.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {8894., 8972., 9050., 9128.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {16768., 17788., 16912., 17944.,
                                         17056., 18100., 17200., 18256.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {16768., 17788., 16912., 17944.,
                                         17056., 18100., 17200., 18256.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      32516., 33536., 34556., 35576., 32792., 33824., 34856., 35888.,
      33068., 34112., 35156., 36200., 33344., 34400., 35456., 36512.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      32516., 33536., 34556., 35576., 32792., 33824., 34856., 35888.,
      33068., 34112., 35156., 36200., 33344., 34400., 35456., 36512.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x4x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7557.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x4x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7557.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x4x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {14520., 15114.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x4x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {14520., 15114.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x4x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {28446., 29040., 29634., 30228.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x4x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {28446., 29040., 29634., 30228.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x4x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {14943., 15114.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x4x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {14943., 15114.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x4x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {28716., 29886., 29040., 30228.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x4x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {28716., 29886., 29040., 30228.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x4x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {56262., 57432., 58602., 59772.,
                                         56892., 58080., 59268., 60456.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x4x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {56262., 57432., 58602., 59772.,
                                         56892., 58080., 59268., 60456.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x4x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {29715., 29886., 30057., 30228.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x4x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {29715., 29886., 30057., 30228.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x4x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {57108., 59430., 57432., 59772.,
                                         57756., 60114., 58080., 60456.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x4x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {57108., 59430., 57432., 59772.,
                                         57756., 60114., 58080., 60456.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x4x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      111894., 114216., 116538., 118860., 112524., 114864., 117204., 119544.,
      113154., 115512., 117870., 120228., 113784., 116160., 118536., 120912.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x4x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      111894., 114216., 116538., 118860., 112524., 114864., 117204., 119544.,
      113154., 115512., 117870., 120228., 113784., 116160., 118536., 120912.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x6x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5895.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x6x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5895.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x6x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {11322., 11790.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x6x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {11322., 11790.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x6x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {22176., 22644., 23112., 23580.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x6x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {22176., 22644., 23112., 23580.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x6x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {11619., 11790.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x6x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {11619., 11790.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x6x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {22320., 23238., 22644., 23580.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x6x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {22320., 23238., 22644., 23580.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x6x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {43722., 44640., 45558., 46476.,
                                         44352., 45288., 46224., 47160.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x6x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {43722., 44640., 45558., 46476.,
                                         44352., 45288., 46224., 47160.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x6x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {23067., 23238., 23409., 23580.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x6x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {23067., 23238., 23409., 23580.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x6x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {44316., 46134., 44640., 46476.,
                                         44964., 46818., 45288., 47160.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x6x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {44316., 46134., 44640., 46476.,
                                         44964., 46818., 45288., 47160.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x6x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      86814., 88632., 90450., 92268., 87444., 89280., 91116., 92952.,
      88074., 89928., 91782., 93636., 88704., 90576., 92448., 94320.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x6x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      86814., 88632., 90450., 92268., 87444., 89280., 91116., 92952.,
      88074., 89928., 91782., 93636., 88704., 90576., 92448., 94320.};
  const std::array<int, 4> in_shape = {{3, 6, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x6x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7743.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x6x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7743.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x6x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {14874., 15486.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x6x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {14874., 15486.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x6x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {29136., 29748., 30360., 30972.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x6x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {29136., 29748., 30360., 30972.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x6x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {15315., 15486.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x6x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {15315., 15486.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x6x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {29424., 30630., 29748., 30972.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x6x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {29424., 30630., 29748., 30972.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x6x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {57642., 58848., 60054., 61260.,
                                         58272., 59496., 60720., 61944.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x6x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {57642., 58848., 60054., 61260.,
                                         58272., 59496., 60720., 61944.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x6x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30459., 30630., 30801., 30972.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x6x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30459., 30630., 30801., 30972.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x6x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {58524., 60918., 58848., 61260.,
                                         59172., 61602., 59496., 61944.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x6x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {58524., 60918., 58848., 61260.,
                                         59172., 61602., 59496., 61944.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x6x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      114654., 117048., 119442., 121836., 115284., 117696., 120108., 122520.,
      115914., 118344., 120774., 123204., 116544., 118992., 121440., 123888.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x6x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      114654., 117048., 119442., 121836., 115284., 117696., 120108., 122520.,
      115914., 118344., 120774., 123204., 116544., 118992., 121440., 123888.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {25794.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {25794.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {50211., 51588.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {50211., 51588.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {99045., 100422., 101799., 103176.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {99045., 100422., 101799., 103176.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {51210., 51588.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {51210., 51588.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {99693., 102420., 100422., 103176.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {99693., 102420., 100422., 103176.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {196659., 199386., 202113., 204840.,
                                         198090., 200844., 203598., 206352.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {196659., 199386., 202113., 204840.,
                                         198090., 200844., 203598., 206352.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {102042., 102420., 102798., 103176.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {102042., 102420., 102798., 103176.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {198657., 204084., 199386., 204840.,
                                         200115., 205596., 200844., 206352.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {198657., 204084., 199386., 204840.,
                                         200115., 205596., 200844., 206352.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, SAME3x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      391887., 397314., 402741., 408168., 393318., 398772., 404226., 409680.,
      394749., 400230., 405711., 411192., 396180., 401688., 407196., 412704.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride2, VALID3x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      391887., 397314., 402741., 408168., 393318., 398772., 404226., 409680.,
      394749., 400230., 405711., 411192., 396180., 401688., 407196., 412704.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}